package com.ruoyi.system.service.impl;

import java.util.List;
import java.util.stream.Collectors;

import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.MilestoneTask;
import com.ruoyi.system.mapper.MilestoneTaskMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.system.mapper.TaskMapper;
import com.ruoyi.system.domain.Task;
import com.ruoyi.system.service.ITaskService;
import org.springframework.transaction.annotation.Transactional;

/**
 * 【请填写功能名称】Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-02-14
 */
@Service
public class TaskServiceImpl implements ITaskService 
{
    @Autowired
    private TaskMapper taskMapper;

    @Autowired
    private MilestoneTaskMapper milestoneTaskMapper;

    /**
     * 查询【请填写功能名称】
     * 
     * @param id 【请填写功能名称】主键
     * @return 【请填写功能名称】
     */
    @Override
    public Task selectTaskById(Long id)
    {
        return taskMapper.selectTaskById(id);
    }

    /**
     * 查询【请填写功能名称】列表
     * 
     * @param task 【请填写功能名称】
     * @return 【请填写功能名称】
     */
    @Override
    public List<Task> selectTaskList(Task task)
    {
        List<Task> tasks = taskMapper.selectTaskList(task);
        for (Task taskDB : tasks) {
            //计算预计完成时间（小时）
            if(taskDB.getPlanEndTime() != null && taskDB.getPlanStartTime() != null){
                taskDB.setEstimateTime((taskDB.getPlanEndTime().getTime() - taskDB.getPlanStartTime().getTime()) / (1000 * 60 * 60));
            }
            //计算时间完成时间
            if(taskDB.getEndTime() != null && taskDB.getPlanStartTime() != null){
                taskDB.setActualTime((taskDB.getEndTime().getTime() - taskDB.getPlanStartTime().getTime()) / (1000 * 60 * 60));
            }
        }
        return tasks.stream().distinct().collect(Collectors.toList());
    }

    /**
     * 新增【请填写功能名称】
     * 
     * @param task 【请填写功能名称】
     * @return 结果
     */
    @Transactional
    @Override
    public int insertTask(Task task)
    {
        //校验前置任务
        vaildateProTask(task);
        int insertTask = taskMapper.insertTask(task);
        //插入中间表 - 里程碑和任务表
        insertMid(task);
        return insertTask;
    }

    /**
     * 修改【请填写功能名称】
     * 
     * @param task 【请填写功能名称】
     * @return 结果
     */
    @Transactional
    @Override
    public int updateTask(Task task)
    {
        //状态为完成，判断前提条件
        vaildateProTask(task);
        insertMid(task);
        return taskMapper.updateTask(task);
    }

    @Transactional
    public void insertMid(Task task) {
        if(task.getMilestoneId() == null){
            return;
        }
        //插入中间表 - 里程碑和任务表
        MilestoneTask milestoneTask = new MilestoneTask();
        milestoneTask.setMilestoneId(task.getMilestoneId());
        milestoneTask.setTaskId(task.getId());
        //先查询是否存在
        MilestoneTask milestoneTaskByMilestoneId = milestoneTaskMapper.selectMilestoneTaskByTaskId(task.getId());

        if(milestoneTaskByMilestoneId == null){
            //插入中间表
            try {
                milestoneTaskMapper.insertMilestoneTask(milestoneTask);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }else {
            //判断里程碑的id是否相同
            if(!milestoneTaskByMilestoneId.getMilestoneId().equals(task.getMilestoneId())){

                milestoneTask.setId(milestoneTaskByMilestoneId.getId());
                //修改中间表
                milestoneTaskMapper.updateMilestoneTask(milestoneTask);
            }
        }
    }

    private void vaildateProTask(Task task) {
        if(StringUtils.isBlank(task.getBeforeId())){
            return;
        }
        String[] beforeIdList = task.getBeforeId().split(",");
        Task protask = null;
        if(task.getStatus().equals("3")){
            String beforeId = task.getBeforeId();
            if(StringUtils.isNotBlank(beforeId)){
                for (String id : beforeIdList) {
                    //判断前置条件
                    protask = taskMapper.selectTaskById(Long.valueOf(id));

                    if(!protask.getStatus().equals("3")){
                        throw new RuntimeException("前置任务[" + protask.getName() + "]未完成，不能完成本任务");
                    }
                }
            }

        }

        //前置任务和当前任务不能存在依赖关系
        Long currentTaskId = task.getId();
        if(currentTaskId != null){
            for (String id : beforeIdList) {

               //前置任务
               protask = taskMapper.selectTaskById(Long.valueOf(id));


                if(currentTaskId.equals(protask.getId())){
                    throw new RuntimeException("前置任务不能是当前任务");
                }

                if(StringUtils.isNotBlank(protask.getBeforeId()) && protask.getBeforeId().contains(currentTaskId.toString())){
                    throw new RuntimeException("前置任务[" + protask.getName() + "]和当前任务不能存在依赖关系");
                }
            }
        }
    }

    /**
     * 批量删除【请填写功能名称】
     * 
     * @param ids 需要删除的【请填写功能名称】主键
     * @return 结果
     */
    @Override
    public int deleteTaskByIds(Long[] ids)
    {
        return taskMapper.deleteTaskByIds(ids);
    }

    /**
     * 删除【请填写功能名称】信息
     * 
     * @param id 【请填写功能名称】主键
     * @return 结果
     */
    @Transactional
    @Override
    public int deleteTaskById(Long id)
    {
        int i = taskMapper.deleteTaskById(id);
        if(i > 0){
            //删除中间表
            milestoneTaskMapper.deleteMilestoneTaskByTaskId(id);
        }else {
            throw new RuntimeException("删除失败");
        }
        return i;
    }

    @Override
    public List<Task> selectTaskListFilter() {
        return taskMapper.selectTaskListFilter();
    }
}
